package cc.beup.common.util;


import java.lang.reflect.Method;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;
import java.util.function.Predicate;

/**
 * @Author: Byron Bai
 * @Date: 2021/4/18 20:13
 * @Description:
 */
public class EnumUtil {

    private EnumUtil() {
    }

    /**
     * 根据条件获取枚举对象，请勿遍历使用
     *
     * @Author: Byron Bai
     * @Date: 2021/4/18 20:11
     */
    public static <T> Optional<T> getEnumObject(Class<T> className, Predicate<T> predicate) {
        if (!className.isEnum()) {
            Optional.empty();
        }
        return Arrays.stream(className.getEnumConstants()).filter(predicate).findAny();
    }

    /**
     * 枚举类转Map
     *
     * @param enumClassName 需要转换的枚举类型
     * @param methodNames   枚举类变量，只支持两个
     * @Author: Byron Bai
     * @Date: 2021/4/18 20:13
     */
    public static <T> Map<Integer, String> enumToMap(Class<T> enumClassName,
                                                     String... methodNames) {
        Map<Integer, String> enumMap = new HashMap<>();
        if (!enumClassName.isEnum()) {
            return enumMap;
        }
        T[] enums = enumClassName.getEnumConstants();
        if (enums == null || enums.length <= 0) {
            return enumMap;
        }
        int count = methodNames.length;
        // 默认变量
        String valueMathod = "getId";
        String desMathod = "getValue";
        // 扩展方法*/
        if (count >= 1 && !"".equals(methodNames[0])) {
            valueMathod = methodNames[0];
        }
        if (count == 2 && !"".equals(methodNames[1])) {
            desMathod = methodNames[1];
        }
        for (T tobj : enums) {
            try {
                // 获取key
                Object resultValue = getMethodValue(valueMathod, tobj);
                if ("".equals(resultValue)) {
                    continue;
                }
                // 获取value
                Object resultDes = getMethodValue(desMathod, tobj);
                if ("".equals(resultDes)) {
                    resultDes = tobj;
                }
                enumMap.put((Integer) resultValue, resultDes + "");
            } catch (Exception e) {
                e.printStackTrace();
            }
        }
        return enumMap;
    }

    /**
     * 根据反射，通过方法名称获取方法值，忽略大小写的
     */
    private static <T> Object getMethodValue(String methodName, T obj, Object... args) {
        Object resut = "";
        try {
            // 获取方法数组，这里只要共有的方法
            Method[] methods = obj.getClass().getMethods();
            if (methods.length <= 0) {
                return resut;
            }
            Method method = null;
            for (Method value : methods) {
                //忽略大小写取方法
                if (value.getName().equalsIgnoreCase(methodName)) {
                    //如果存在，则取出正确的方法名称
                    methodName = value.getName();
                    method = value;
                    break;
                }
            }
            if (method == null) {
                return resut;
            }
            // 方法执行
            resut = method.invoke(obj, args);
            if (resut == null) {
                resut = "";
            }
            // 返回结果
            return resut;
        } catch (Exception e) {
            e.printStackTrace();
        }
        return resut;
    }

}
